home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1999 #2 / Amiga Plus CD - 1999 - No. 2.iso / System-Boost / Workbench / ToolManager / Source / Library / handler.c < prev    next >
C/C++ Source or Header  |  1998-06-17  |  9KB  |  344 lines
  1. /*
  2.  * handler.c  V3.1
  3.  *
  4.  * ToolManager handler main loop
  5.  *
  6.  * Copyright (C) 1990-98 Stefan Becker
  7.  *
  8.  * This source code is for educational purposes only. You may study it
  9.  * and copy ideas or algorithms from it for your own projects. It is
  10.  * not allowed to use any of the source codes (in full or in parts)
  11.  * in other programs. Especially it is not allowed to create variants
  12.  * of ToolManager or ToolManager-like programs from this source code.
  13.  *
  14.  */
  15.  
  16. #include "toolmanager.h"
  17.  
  18. /* Global data */
  19. struct Library *DOSBase                        = NULL;
  20. struct Library *GfxBase                        = NULL;
  21. struct Library *IntuitionBase                  = NULL;
  22. struct Library *UtilityBase                    = NULL;
  23. Class          *ToolManagerClasses[TMOBJTYPES] = { NULL, NULL, NULL, NULL,
  24.                                                    NULL, NULL, NULL };
  25. Class          *ToolManagerGroupClass          = NULL;
  26. Class          *ToolManagerButtonClass         = NULL;
  27. Class          *ToolManagerEntryClass          = NULL;
  28.  
  29. /* Local data */
  30. static struct TMHandle *InternalTMHandle     = NULL;
  31. static Class           *ToolManagerBaseClass = NULL;
  32. static LONG             LowMemorySignal      = -1;
  33. static LONG             IDCMPSignal          = -1;
  34. static LONG             BrokerSignal         = -1;
  35. static LONG             AppMessagesSignal    = -1;
  36. static LONG             NetworkSignal        = -1;
  37. static LONG             ScreenNotifySignal   = -1;
  38. static LONG             IPCSignal            = -1;
  39. static LONG             NotifySignal         = -1;
  40.  
  41. /* Allocate resources */
  42. static BOOL GetResources(void)
  43. {
  44.  return(/* Libraries */
  45.         (DOSBase       = OpenLibrary(DosName,               39)) &&
  46.         (GfxBase       = OpenLibrary("graphics.library",    39)) &&
  47.         (IntuitionBase = OpenLibrary("intuition.library",   39)) &&
  48.         (UtilityBase   = OpenLibrary("utility.library",     39)) &&
  49.  
  50.         /* Workbench path */
  51.         GetWorkbenchPath() &&
  52.  
  53.         /* Memory management */
  54.         InitMemory() &&
  55.  
  56.         /* Classes */
  57.         (ToolManagerBaseClass = CreateBaseClass()) &&
  58.         (ToolManagerClasses[TMOBJTYPE_EXEC] =
  59.                                      CreateExecClass(ToolManagerBaseClass)) &&
  60.         (ToolManagerClasses[TMOBJTYPE_IMAGE] =
  61.                                      CreateImageClass(ToolManagerBaseClass)) &&
  62.         (ToolManagerClasses[TMOBJTYPE_SOUND] =
  63.                                      CreateSoundClass(ToolManagerBaseClass)) &&
  64.         (ToolManagerClasses[TMOBJTYPE_MENU] =
  65.                                      CreateMenuClass(ToolManagerBaseClass)) &&
  66.         (ToolManagerClasses[TMOBJTYPE_ICON] =
  67.                                      CreateIconClass(ToolManagerBaseClass)) &&
  68.         (ToolManagerClasses[TMOBJTYPE_DOCK] =
  69.                                      CreateDockClass(ToolManagerBaseClass)) &&
  70.         (ToolManagerGroupClass  = CreateGroupClass()) &&
  71.         (ToolManagerButtonClass = CreateButtonClass()) &&
  72.         (ToolManagerEntryClass  = CreateEntryClass()) &&
  73.  
  74.         /* Low memory warning */
  75.         ((LowMemorySignal    = StartLowMemoryWarning())   != -1) &&
  76.  
  77.         /* IDCMP */
  78.         ((IDCMPSignal        = StartIDCMP())              != -1) &&
  79.  
  80.         /* Commodities */
  81.         ((BrokerSignal       = StartCommodities())        != -1) &&
  82.  
  83.         /* WB application messages */
  84.         ((AppMessagesSignal  = StartAppMessages())        != -1) &&
  85.  
  86.         /* Networking */
  87.         ((NetworkSignal      = StartNetwork())            != -1) &&
  88.  
  89.         /* ScreenNotify */
  90.         ((ScreenNotifySignal = StartScreenNotify())       != -1) &&
  91.  
  92.         /* IPC Library <-> Handler */
  93.         ((IPCSignal          = StartIPC())                != -1) &&
  94.  
  95.         /* Configuration file notification */
  96.         ((NotifySignal       = StartConfigChangeNotify()) != -1) &&
  97.  
  98.         /* Misc. */
  99.         (InternalTMHandle = GetMemory(sizeof(struct TMHandle))) &&
  100.         (InitHandles(), InitToolManagerHandle(InternalTMHandle))
  101.        );
  102. }
  103.  
  104. /* Free resources */
  105. static void FreeResources(void)
  106. {
  107.  int i;
  108.  
  109.  /* Misc. */
  110.  if (InternalTMHandle) {
  111.   DeleteToolManagerHandle(InternalTMHandle);
  112.   FreeMemory(InternalTMHandle, sizeof(struct TMHandle));
  113.   InternalTMHandle = NULL;
  114.  }
  115.  
  116.  /* Free global parameters */
  117.  FreeGlobalParameters();
  118.  
  119.  /* Configuration file notification */
  120.  if (NotifySignal != -1) {
  121.   StopConfigChangeNotify();
  122.   NotifySignal = -1;
  123.  }
  124.  
  125.  /* IPC */
  126.  if (IPCSignal != -1) {
  127.   StopIPC();
  128.   IPCSignal = -1;
  129.  }
  130.  
  131.  /* ScreenNotify */
  132.  if (ScreenNotifySignal != -1) {
  133.   StopScreenNotify();
  134.   ScreenNotifySignal = -1;
  135.  }
  136.  
  137.  /* Networking */
  138.  if (NetworkSignal != -1) {
  139.   StopNetwork();
  140.   NetworkSignal = -1;
  141.  }
  142.  
  143.  /* WB application messages */
  144.  if (AppMessagesSignal != -1) {
  145.   StopAppMessages();
  146.   AppMessagesSignal = -1;
  147.  }
  148.  
  149.  /* Commodities */
  150.  if (BrokerSignal != -1) {
  151.   StopCommodities();
  152.   BrokerSignal = -1;
  153.  }
  154.  
  155.  /* IDCMP */
  156.  if (IDCMPSignal != -1) {
  157.   StopIDCMP();
  158.   IDCMPSignal = -1;
  159.  }
  160.  
  161.  /* Low memory warning */
  162.  if (LowMemorySignal != -1) {
  163.   StopLowMemoryWarning();
  164.   LowMemorySignal = -1;
  165.  }
  166.  
  167.  /* Classes */
  168.  if (ToolManagerEntryClass) {
  169.   FreeClass(ToolManagerEntryClass);
  170.   ToolManagerEntryClass = NULL;
  171.  }
  172.  if (ToolManagerButtonClass) {
  173.   FreeClass(ToolManagerButtonClass);
  174.   ToolManagerButtonClass = NULL;
  175.  }
  176.  if (ToolManagerGroupClass) {
  177.   FreeClass(ToolManagerGroupClass);
  178.   ToolManagerGroupClass = NULL;
  179.  }
  180.  for (i = TMOBJTYPES - 1; i >= 0; i--)
  181.   if (ToolManagerClasses[i]) {
  182.    FreeClass(ToolManagerClasses[i]);
  183.    ToolManagerClasses[i] = NULL;
  184.   }
  185.  if (ToolManagerBaseClass) {
  186.   FreeClass(ToolManagerBaseClass);
  187.   ToolManagerBaseClass = NULL;
  188.  }
  189.  
  190.  /* Memory management */
  191.  DeleteMemory();
  192.  
  193.  /* Workbench path */
  194.  FreeWorkbenchPath();
  195.  
  196.  /* Libraries */
  197.  if (UtilityBase) {
  198.   CloseLibrary(UtilityBase);
  199.   UtilityBase = NULL;
  200.  }
  201.  if (IntuitionBase) {
  202.   CloseLibrary(IntuitionBase);
  203.   IntuitionBase = NULL;
  204.  }
  205.  if (GfxBase) {
  206.   CloseLibrary(GfxBase);
  207.   GfxBase = NULL;
  208.  }
  209.  if (DOSBase) {
  210.   CloseLibrary(DOSBase);
  211.   DOSBase = NULL;
  212.  }
  213. }
  214.  
  215. /* ToolManager Handler entry point */
  216. #undef  DEBUGFUNCTION
  217. #define DEBUGFUNCTION ToolManagerHandler
  218. __geta4 void ToolManagerHandler(void)
  219. {
  220. #ifdef DEBUG
  221.  /* Store original state */
  222.  ULONG OldSigAlloc = FindTask(NULL)->tc_SigAlloc;
  223. #endif
  224.  
  225.  HANDLER_LOG(LOG0(Handler starting))
  226.  
  227.  /* Start localization */
  228.  StartLocale();
  229.  
  230.  /* Allocate resources */
  231.  if (GetResources()) {
  232.   ULONG memmask;
  233.   ULONG winmask;
  234.   ULONG brkmask;
  235.   ULONG apmmask;
  236.   ULONG ntwmask;
  237.   ULONG scnmask;
  238.   ULONG ipcmask;
  239.   ULONG cfnmask;
  240.   ULONG sigmask;
  241.   BOOL  configactive = FALSE;
  242.  
  243.   HANDLER_LOG(LOG0(Handler running))
  244.  
  245.   /* Announce IPC port */
  246.   ToolManagerBase->tmb_Port = GetIPCPort();
  247.  
  248.   /* Set handler state to running */
  249.   ToolManagerBase->tmb_State = TMHANDLER_RUNNING;
  250.  
  251.   /* Initialize signal masks */
  252.   memmask = (1 << LowMemorySignal);
  253.   winmask = (1 << IDCMPSignal);
  254.   brkmask = (1 << BrokerSignal);
  255.   apmmask = (1 << AppMessagesSignal);
  256.   ntwmask = (1 << NetworkSignal);
  257.   scnmask = (1 << ScreenNotifySignal);
  258.   ipcmask = (1 << IPCSignal);
  259.   cfnmask = (1 << NotifySignal);
  260.   sigmask = memmask | winmask | brkmask | apmmask | ntwmask | scnmask |
  261.             ipcmask | cfnmask |
  262.             SIGBREAKF_CTRL_F;
  263.  
  264.   /* Main event loop */
  265.   while (ToolManagerBase->tmb_State != TMHANDLER_LEAVING) {
  266.    ULONG signals;
  267.  
  268.    /* If configuration is not active, then wait on next event  */
  269.    /* Otherwise use Wait() only if some of our signals are set */
  270.    if ((configactive == FALSE) || (signals = SetSignal(0, 0) & sigmask))
  271.  
  272.     /* Read and clear signals */
  273.     signals = Wait(sigmask);
  274.  
  275.    HANDLER_LOG(LOG1(Wait, "Signals 0x%08lx", signals))
  276.  
  277.    /* Low memory warning? */
  278.    if (signals & memmask) HandleLowMemory();
  279.  
  280.    /* IDCMP event? */
  281.    if (signals & winmask) HandleIDCMP();
  282.  
  283.    /* Commodities event? */
  284.    if (signals & brkmask) HandleCommodities();
  285.  
  286.    /* WB application message event? */
  287.    if (signals & apmmask) HandleAppMessages();
  288.  
  289.    /* Network event ? */
  290.    if (signals & ntwmask) HandleNetwork();
  291.  
  292.    /* ScreenNotify event? */
  293.    if (signals & scnmask) HandleScreenNotify();
  294.  
  295.    /* Message from library routines? */
  296.    if (signals & ipcmask) HandleIPC();
  297.  
  298.    /* Configuration file changed? */
  299.    if (signals & cfnmask) {
  300.  
  301.     /* Yes, delete old configuration */
  302.     DeleteToolManagerHandle(InternalTMHandle);
  303.  
  304.     /* Initialize TMHandle for new objects */
  305.     InitToolManagerHandle(InternalTMHandle);
  306.  
  307.     /* Start to read the new configuration */
  308.     configactive = HandleConfigChange();
  309.    }
  310.  
  311.    /* If configuration is active then parse next configuration element */
  312.    if (configactive) configactive = NextConfigParseStep(InternalTMHandle);
  313.   }
  314.  
  315.   /* Remove IPC Port */
  316.   ToolManagerBase->tmb_Port = NULL;
  317.  }
  318.  
  319.  HANDLER_LOG(LOG0(Handler leaving))
  320.  
  321.  /* Free Resources */
  322.  FreeResources();
  323.  
  324.  /* Stop localization */
  325.  StopLocale();
  326.  
  327. #ifdef DEBUG
  328.  /* Check allocated signals */
  329.  if (OldSigAlloc ^= FindTask(NULL)->tc_SigAlloc) {
  330.  
  331.   /* Print remaining allocated signal bits */
  332.   ERROR_LOG(LOG1(Unfreed signals, "0x%08lx", OldSigAlloc))
  333.  
  334.  } else {
  335.  
  336.   INFORMATION_LOG(LOG0(All signals released))
  337.  }
  338. #endif
  339.  
  340.  /* Shut down handler */
  341.  Forbid();
  342.  ToolManagerBase->tmb_State = TMHANDLER_INACTIVE;
  343. }
  344.